home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et-2_2.lha / et2.2 / src / Object.C < prev    next >
C/C++ Source or Header  |  1990-12-19  |  11KB  |  523 lines
  1. //$Object,ChangeMessage,FindMember$
  2. #include "Object.h"
  3. #include "OrdColl.h"
  4. #include "IdDictionary.h"
  5. #include "ObjInt.h"
  6. #include "Error.h"
  7. #include "String.h"
  8. #include "Storage.h"
  9. #include "ProgEnv.h"
  10. #include "System.h"
  11. #include "ObjectTable.h"
  12. #include "ClassManager.h"
  13. #include "AccessMem.h"
  14. #include "IO/membuf.h"
  15.  
  16. bool gInPrintOn;
  17. bool gAddToInstTable= TRUE;
  18.  
  19. extern void InitProgenv();
  20.   
  21. //---- observing ---------------------------------------------------------
  22.  
  23. static IdDictionary *Observer; 
  24. // dictionary associating a list of observers with an Object
  25.  
  26. static IdDictionary *DelayedChanges; 
  27. // dictionary to store the delayed Change messages, the key is the object pointer
  28. // (IdDictionary) the value is an OrderedCollection of ChangeMessages (see below).
  29. // The first entry of the OrderedCollection is a reference count of the number of
  30. // DelayChanges requests. FlushChanges will be executed when the count drops to 0.
  31. // Whether change messages are delayed is set with the cObjDelayChanges flag
  32.  
  33.  
  34. struct ChangeMessage: public Object {
  35.     void *what;
  36.     int part, id;
  37.  
  38.     ChangeMessage(void *w, int p, int i)
  39.     { what= w; part= p; id= i; }
  40. };
  41.  
  42. //---- automatically added by macro metaImpl -----------------------------------
  43.  
  44. static Class ObjectClassMetaImpl0("Object",
  45.                   sizeof (Object),
  46.                   new Object((_dummy*)0),
  47.                   __FILE__,
  48.                   "./Object.h",
  49.                   __LINE__,
  50.                   1,
  51.                   TRUE);
  52.  
  53. Object::Object(class _dummy*)
  54. {
  55.     flags= cObjNonDeleted | cObjIsProto;
  56.     isa= &ObjectClassMetaImpl0;
  57.     ObjectClassMetaImpl0.SetSuper();
  58. }
  59.  
  60. Class *Object::IsA()
  61. {
  62.     return &ObjectClassMetaImpl0;
  63. }
  64.  
  65. void Object::Members()
  66. {
  67.     TheThis= this;
  68.     D_F(TX(flags), 0);    
  69. }
  70.  
  71. //---- ordinary methods ----------------------------------------------------
  72.  
  73. Object::Object(int f)
  74. {
  75.     flags= (f & cFlagMask) | cObjNonDeleted;
  76.     ObjectTable::Add(this);
  77. }
  78.  
  79. Object::~Object()
  80. {
  81.     if (! TestFlag(cObjNonDeleted)) {
  82.     if (gDebug)
  83.         Fatal("~Object", "object deleted twice");
  84.     return;
  85.     }
  86.   
  87.     ObjectTable::Remove(this);
  88.     flags&= ~cObjNonDeleted;
  89.     if (gInPrintOn) 
  90.     gClassManager->InvalidatePtr(this);
  91.     
  92.     if (IsObserved()) {
  93.     Collection *observers= GetObservers(); // GetObservers is statically bound!!!
  94.     flags &= ~cObjIsObserved;
  95.     if (observers)
  96.         CleanupObservers(observers);
  97.     }
  98. }
  99.  
  100. void Object::FreeAll()
  101. {
  102. }
  103.  
  104. char *Object::ClassName()
  105. {
  106.     return IsA()->Name();
  107. } 
  108.  
  109. ObjPtr Object::New()
  110. {
  111.     return IsA()->New();
  112. }
  113.  
  114. void Object::InitNew()
  115. {
  116. }
  117.  
  118. void Object::Inspect(bool block)
  119. {
  120.     InitProgenv();
  121.     gProgEnv->InspectObject(this, block);
  122. }
  123.  
  124. void Object::EditSource(bool definition)
  125. {
  126.     InitProgenv();
  127.     gProgEnv->EditSourceOf(IsA(), definition);
  128. }
  129.  
  130. void Object::InspectorId(char *buf, int)
  131. {
  132.     buf= "";
  133. }
  134.  
  135. void Object::Parts(class Collection *)
  136. {
  137. }
  138.  
  139. void Object::DoError(int level, char *location, char *fmt, va_list va)
  140. {
  141.     ::ErrorHandler(level, form("%s::%s", ClassName(), location), fmt, va);
  142. }
  143.  
  144. void Object::Error(char *location, char *va_(fmt), ...)
  145. {
  146.     va_list ap;
  147.     va_start(ap,va_(fmt));
  148.     DoError(cError, location, va_(fmt), ap);
  149.     va_end(ap);
  150. }
  151.  
  152. void Object::SysError(char *location,  char *va_(fmt), ...)
  153. {
  154.     va_list ap;
  155.     va_start(ap,va_(fmt));
  156.     DoError(cSysError, location, va_(fmt), ap);
  157.     va_end(ap);
  158. }
  159.  
  160. void Object::Warning(char *location, char *va_(fmt), ...)
  161. {
  162.     va_list ap;
  163.     va_start(ap,va_(fmt));
  164.     DoError(cWarning, location, va_(fmt), ap);
  165.     va_end(ap);
  166. }
  167.  
  168. void Object::Fatal(char *location, char *va_(fmt), ...)
  169. {
  170.     va_list ap;
  171.     va_start(ap,va_(fmt));
  172.     DoError(cFatal, location, va_(fmt), ap);
  173.     va_end(ap);
  174. }
  175.  
  176. Object *Object::Clone()
  177. {
  178.     Object *clone= New();
  179.  
  180.     if (clone)
  181.     BCOPY((byte*) this, (byte*) clone, IsA()->Size());
  182.     return clone;
  183. }
  184.  
  185. Object *Object::DeepClone()
  186. {
  187.     int status;
  188.     membuf mb;
  189.     ostream to(&mb);
  190.     istream from(&mb);
  191.     ObjPtr op;
  192.  
  193.     gClassManager->Reset();
  194.     gInPrintOn= TRUE;
  195.     to << this NL;
  196.     to.flush();
  197.     gInPrintOn= FALSE;
  198.     
  199.     gClassManager->Reset();
  200.     from >> op;
  201.     if (status= gClassManager->Reset()) {
  202.     Error("DeepClone", "status %d", status);
  203.     return 0;
  204.     }
  205.     return op;
  206. }
  207.  
  208. void Object::SetFlag(int f, bool b)
  209. {
  210.     if (b)
  211.     SetFlag(f);
  212.     else
  213.     ResetFlag(f);
  214. }
  215.  
  216. //---- fire walls ----------------------------------------------------------
  217.  
  218. void Object::AbstractMethod(char *method)
  219. {
  220.     Warning(method, "abstract method called"); 
  221. }
  222.  
  223. void Object::MayNotUse(char *method)
  224. {
  225.     Warning(method, "not allowed to use this method");
  226. }
  227.  
  228. Object *Object::guard(Class *should)
  229. {
  230.     if (this != 0 && IsA()->isKindOf(should))
  231.     return this;
  232.     Error("Guard", "object is not a %s but a %s", should->Name(), ClassName());
  233.     return 0;
  234. }
  235.  
  236. //---- comparing -----------------------------------------------------------
  237.  
  238. u_long Object::Hash () 
  239. {
  240.     return (u_long) this;
  241. }
  242.  
  243. bool Object::IsEqual (Object *anOp)
  244. {
  245.      return anOp == this;
  246. }
  247.  
  248. int Object::Compare (Object*)
  249. {
  250.     AbstractMethod ("Compare");
  251.     return 0;
  252. }
  253.  
  254. //---- Object Observing --------------------------------------------------------
  255.  
  256. void Object::AddObserver (ObjPtr op)
  257. {
  258.     Collection *observer;
  259.     
  260.     if (op) {
  261.     if (!IsObserved() || ((observer= GetObservers()) == 0)) {
  262.         flags |= cObjIsObserved; 
  263.         observer= MakeObserverColl();
  264.     } else {
  265.         if (observer->FindPtr(op)) {
  266.         Warning("AddObserver", "duplicate in observers");
  267.         return;
  268.         }
  269.     }
  270.     observer->Add (op);
  271.     }
  272. }
  273.  
  274. ObjPtr Object::RemoveObserver (ObjPtr op)
  275. {
  276.     if (this && IsObserved()) {
  277.     Collection *observers= GetObservers();
  278.     if (observers) {
  279.         if (op) 
  280.         op= observers->RemovePtr(op);
  281.         if (observers->IsEmpty()) {
  282.         flags &= ~cObjIsObserved;
  283.         DestroyObserverColl();
  284.         }
  285.         return op;
  286.     }
  287.     }
  288.     return 0;
  289. }
  290.  
  291. void Object::Send(int id, int part, void *vp)
  292. {
  293.     if (!IsObserved())
  294.     return;
  295.     if (TestFlag(cObjDelayChanges)) {
  296.     if (DelayedChanges == 0)
  297.         ObjectTable::AddRoot(DelayedChanges= new IdDictionary);
  298.     Collection *col= (Collection*) DelayedChanges->AtKey(this);
  299.     if (!col)
  300.         Error("Send", "No collection for change messages, %s", ClassName());
  301.     col->Add(new ChangeMessage(vp, part, id));
  302.     DelayedChanges->AtKeyPut(this,col);
  303.     } else {
  304.     Collection *observers= GetObservers();
  305.     if (observers)
  306.         observers->ForEach(Object,DoObserve)(id, part, vp, this);
  307.     }
  308. }
  309.  
  310. void Object::DoObserve(int id, int part, void *vp, Object *op)
  311. {
  312. }
  313.  
  314. void Object::DelayChanges()
  315. {
  316.     flags |= cObjDelayChanges;
  317.     if (DelayedChanges == 0)
  318.     ObjectTable::AddRoot(DelayedChanges= new IdDictionary);
  319.     Collection *col= (Collection*) DelayedChanges->AtKey(this);
  320.     if (!col) {
  321.     col= new OrdCollection;
  322.     col->Add(new ObjInt(0));
  323.     DelayedChanges->AtKeyPut(this,col);
  324.     } else { // increment reference count
  325.     ObjInt *ref= (ObjInt*)col->At(0);
  326.     (*ref)++;
  327.     }
  328. }
  329.  
  330. void Object::FlushChanges()
  331. {
  332.     if (DelayedChanges == 0)
  333.     ObjectTable::AddRoot(DelayedChanges= new IdDictionary);
  334.     Collection *col= (Collection*) DelayedChanges->AtKey(this);
  335.     if (col) {
  336.     ObjInt *ref= (ObjInt*)col->At(0);
  337.     if (ref->GetValue() == 0) {
  338.         flags &= ~cObjDelayChanges;
  339.         ChangeMessage *cm;
  340.         Iter next(col);
  341.         next(); // overread reference count
  342.         while (cm= (ChangeMessage*) next()) 
  343.         Send(cm->id, cm->part, cm->what);
  344.         col->FreeAll();
  345.         Object *tmp= DelayedChanges->RemoveKey(this);
  346.         delete tmp;
  347.     } else 
  348.         (*ref)--;
  349.     }   
  350. }
  351.  
  352. class Iterator *Object::GetObserverIter()        
  353. {
  354.     if (!IsObserved())
  355.     return 0;
  356.     Collection *observers= GetObservers(); 
  357.     if (observers)
  358.     return observers->MakeIterator();
  359.     return 0;
  360. }
  361.  
  362. bool Object::PrintOnWhenObserved(Object*)
  363. {
  364.     return TRUE;    
  365. }
  366.  
  367. Collection *Object::MakeObserverColl()
  368. {
  369.     if (Observer == 0)
  370.     ObjectTable::AddRoot(Observer= new IdDictionary(70));
  371.     Collection *cp= new OrdCollection;
  372.     Observer->AtKeyPut(this, cp);
  373.     return cp;
  374. }
  375.  
  376. Collection *Object::GetObservers()
  377. {
  378.     if (Observer == 0) {
  379.     Warning("GetObservers", "without SetObserver");
  380.     return 0;
  381.     }      
  382.     Collection *cp= (Collection*) Observer->AtKey(this);
  383.     if (cp == 0) 
  384.     Warning("GetObservers", "observers = 0 in GetObservers for %s", ClassName());
  385.     return cp;
  386. }
  387.  
  388. void Object::DestroyObserverColl()
  389. {
  390.     Assoc *op= (Assoc*)Observer->RemoveKey(this);
  391.     Object *observers= op->Value();
  392.     if (observers == 0)
  393.     Warning ("DestroyObserverColl", "0 in DestroyObserverColl() for %s", ClassName());
  394.     SafeDelete(op);
  395.     SafeDelete(observers);
  396. }
  397.  
  398. void Object::SetObserverColl(Collection *cp)
  399. {
  400.     Object *op= Observer->RemoveKey(this);
  401.     SafeDelete(op);
  402.     Observer->AtKeyPut(this, cp);        
  403. }
  404.  
  405. void Object::CleanupObservers(Collection *observers)
  406. {
  407.     observers->ForEach(Object,DoObserve)(-1, cPartSenderDied, 0, this);
  408.     DestroyObserverColl();
  409. }
  410.  
  411. IdDictionary *ObjectGetObservers()
  412. {
  413.     return Observer;
  414. }
  415.  
  416. //---- converting --------------------------------------------------------------
  417.  
  418. char* Object::AsString()
  419. {
  420.     return "";
  421. }
  422.  
  423. //---- activation/passivation --------------------------------------------------
  424.  
  425. static bool printOnWhenObserved(ObjPtr, ObjPtr op, Object *from)
  426. {
  427.     return op->PrintOnWhenObserved(from);
  428. }
  429.  
  430. ostream &Object::PrintOn(ostream &os)
  431. {
  432.     Collection *selectedDeps= 0;
  433.         
  434.     IsA()->MakeIndex(this);
  435.     if (IsObserved()) {
  436.     Collection *observers= GetObservers();
  437.     if (observers->IsEmpty()) { // impossible ??
  438.         flags &= ~cObjIsObserved;
  439.         DestroyObserverColl();
  440.     } else {
  441.         selectedDeps= observers->Select((BoolFun)printOnWhenObserved, this);
  442.         if (selectedDeps->IsEmpty())
  443.         SafeDelete(selectedDeps);
  444.     }
  445.     }
  446.     os << (flags & cFlagMask) SP << selectedDeps SP;
  447.     SafeDelete(selectedDeps);
  448.     return os;
  449. }
  450.  
  451. ostream &operator<< (ostream& s, ObjPtr p)
  452. {
  453.     return gClassManager->SavePtr(s, p);
  454. }
  455.  
  456. istream &LoadPtr(istream &s, Object *&op, Class *cl)
  457. {
  458.     return gClassManager->LoadPtr(s, op, cl);
  459. }
  460.  
  461. istream &Object::ReadFrom(istream &is)
  462. {
  463.     int f;
  464.     Collection *observers;
  465.     
  466.     IsA()->MakeIndex(this);
  467.     is >> f >> observers;
  468.     SetFlag(f);
  469.     if (observers) {
  470.     flags |= cObjIsObserved;
  471.     SetObserverColl(observers);
  472.     }
  473.     return is;
  474. }
  475.  
  476. ostream &Object::DisplayOn(ostream &o)
  477. {
  478.     return o NL;
  479. }
  480.  
  481. //---- FindMember --------------------------------------------------------------
  482.  
  483. class FindMember: public AccessMembers {
  484. public:
  485.     const char *lookfor;
  486.     short offset;
  487.     int len;
  488.     int type;
  489.     Object *op;
  490.     Class *classp;
  491.     
  492.     FindMember(Object *in, const char *name)
  493.     { offset= -1; op= in; lookfor= name; type= 0; len= -1;}
  494.     void Member(char *name, short offset, short lenOrOffset, int type, Class*);
  495. };
  496.  
  497. void FindMember::Member(char *name, short o, short l, int t, Class *c)
  498. {
  499.     if (strcmp(name, lookfor) == 0) {
  500.     offset= o;
  501.     type= t;
  502.     classp= c;
  503.     if (l == -1)
  504.         len= GetLength(op, l, t);
  505.     }
  506. }
  507.  
  508. //---- interface for accessing instance variables by name will be improved
  509. //     in a next release
  510.  
  511. void *Object::GetAddrOf(const char *name, Class *&cl)
  512. {
  513.     FindMember m(this, name);
  514.     IsA()->EnumerateMembers(&m);
  515.     if (m.offset != -1) {
  516.     cl= m.classp;
  517.     return (void*) ((u_long) this + (u_long) m.offset);
  518.     }
  519.     else
  520.     return 0;
  521. }
  522.  
  523.